package com.huiquan.framework.utils;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class StringPatternUtils {

	public static List<String> getGroups(Pattern p, String s) {
		Matcher m = p.matcher(s);

		List<String> groups = new ArrayList<>();

		while (m.find()) {
			groups.add(m.group());
		}

		return groups;
	}

	public static List<String> getGroups(String regex, String s) {

		Pattern p = Pattern.compile(regex);

		return getGroups(p, s);
	}

	/**
	 * 利用正则表达式判断字符串是否是正实数，并返回实数结果
	 * 
	 * @param str
	 * @return 匹配正确则返回Double数字，否则返回null
	 */
	public static Double getPositiveRealNumber(String str) {
		if (str == null || str.isEmpty()) {
			return null;
		}

		Pattern pattern = Pattern.compile("^([1-9][0-9]*|0)(\\.[0-9]+)?$");
		Matcher isNum = pattern.matcher(str);
		if (!isNum.matches()) {
			return null;
		}

		return Double.parseDouble(str);
	}

	/**
	 * 利用正则表达式判断字符串是否是正整数，并返回整数结果
	 * 
	 * @param str
	 * @return 匹配正确则返回Integer数字，否则返回null
	 */
	public static Integer getPositiveInteger(String str) {
		if (str == null || str.isEmpty()) {
			return null;
		}

		Pattern pattern = Pattern.compile("^[1-9][0-9]*$");
		Matcher isNum = pattern.matcher(str);
		if (!isNum.matches()) {
			return null;
		}

		return Integer.parseInt(str);
	}

	public static Integer fomatMixedCHArabPositiveInteger(String str) {
		if (str == null || str.isEmpty()) {
			return null;
		}

		Map<String, String> map = new HashMap<>();
		map.put("1", "一");
		map.put("2", "二");
		map.put("3", "三");
		map.put("4", "四");
		map.put("5", "五");
		map.put("6", "六");
		map.put("7", "七");
		map.put("8", "八");
		map.put("9", "九");

		for (String key : map.keySet()) {
			str = str.replace(key, map.get(key));
		}

		return fomatCN2PositiveInteger(str);
	}

	private static final char[] digits = { '十', '百', '千', '万' }; // 位数
	private static final char[] numChars = { '一', '二', '三', '四', '五', '六', '七', '八', '九' }; // 个位数
	private static final Map<Character, Integer> digitMultiple = new HashMap<>();
	static {
		digitMultiple.put('十', 10);
		digitMultiple.put('百', 100);
		digitMultiple.put('千', 1000);
		digitMultiple.put('万', 10000);
	}

	public static Integer fomatCN2PositiveInteger(String str) {
		if (str == null || str.isEmpty()) {
			System.out.println("字符串为空！");
			return null;
		}
		str = str.replace("两百", "二百");
		str = str.replace("两千", "二千");
		str = str.replace("两万", "二万");

		int lastCharType = 0; // 记录上一个字符是那种类型：1-个位数；2-位数
		int number = -1; // 记录每个数字字符对应的值
		int digitNumber = 4; // 记录上一个位数，每次位数不能超过上次的位数
		boolean lingFlag = false;
		int result = 0;

		for (int i = 0; i < str.length(); i++) {
			char c = str.charAt(i);

			int index = 0; // 记录是数组第几位
			if ((index = checkArray(c, numChars)) > -1) { // 判断是否是个位数
				if (lastCharType == 1) {
					// 如果上一个也是个位数则格式错误
					return null;
				}
				number = index + 1;
				lastCharType = 1;
			} else if ((index = checkArray(c, digits)) > -1) {
				// 如果位数错误则失败
				if (index >= digitNumber) {
					return null;
				}
				if (lingFlag && digitNumber - index == 1) {
					return null;
				}
				digitNumber = index;

				// 如果上一个字符不是个位数，则只有十可以自动补全1，其他都失败
				if (number == -1) {
					if ('十' == c) {
						number = 1;
					} else {
						return null;
					}
				}

				result += number * digitMultiple.get(c);
				number = -1; // 使用过后还原到-1
				lastCharType = 2;
			} else if (c == '零') {
				if (number > -1) {
					return null;
				}
				lingFlag = true;
			} else {
				return null;
			}
		}

		if (number > -1) {
			if (lingFlag) {
				if (digitNumber > 0 && digitNumber < 4) {
					result += number;
				} else {
					return null;
				}
			} else {
				if (digitNumber > 0 && digitNumber < 4) {
					result += number * digitMultiple.get(digits[digitNumber - 1]);
				} else {
					result += number;
				}
			}
		} else if (lingFlag) {
			return null;
		}

		return result;
	}

	/**
	 * 校验该字符是否在字符数组中，如果在返回位置，否则返回-1
	 * 
	 * @param c
	 * @param array
	 * @return
	 */
	private static int checkArray(char c, char[] array) {
		int result = -1;

		for (int i = 0; i < array.length; i++) {
			if (array[i] == c) {
				return i;
			}
		}
		return result;
	}

	public static void main(String[] args) {
		System.out.println(getPositiveInteger("0120"));
	}
}
